"""
设备控制业务接口定义模块
========================

定义了工业设备控制的完整业务接口，包括设备连接管理、状态监控、数据读写、
设备控制命令、实时数据订阅、报警管理等功能。

该模块提供了一套标准化的接口，便于上层应用调用各种设备控制功能，
同时保证了接口设计的合理性、成熟性、鲁棒性和规范化。
"""

from abc import ABC, abstractmethod
from typing import Any, Dict, List, Optional, Union, Callable
from enum import Enum

from .communication_interface import CommunicationInterface
from .heartbeat import HeartbeatMonitor
from ..readwrite.read_interface import ReadInterface
from ..readwrite.write_interface import WriteInterface
from ..readwrite.typedef import *

class DeviceInterface(ReadInterface,WriteInterface):
    """
    基础设备控制业务接口类

    定义了设备控制所需的各种基础业务接口，所有具体的设备控制实现都应继承此类。
    为了允许设备选择性地实现功能，此类为大多数方法提供了默认实现，这些默认实现会抛出
    NotImplementedError 异常。具体的设备实现类只需重写其实际支持的方法。
    """

    def __init__(self, communication: CommunicationInterface, address_mapping: Union[str, Dict[str, Any], object] = None):
        """
        初始化设备控制接口

        Args:
            communication: 通信接口实例
            address_mapping: 地址映射配置（可选），用于设备地址转换
                           可以是JSON文件路径、字典或其他对象
        """
        self.communication = communication
        self.address_mapping = address_mapping
        self._heartbeat_monitor = HeartbeatMonitor(self)

    # 0. 设备初始化
    @abstractmethod
    def initialize(self) -> bool:
        """
        初始化设备

        Returns:
            bool: 初始化是否成功
        """
        pass

    # 1. 设备连接管理
    def connect(self) -> bool:
        """
        连接设备

        Returns:
            bool: 连接是否成功
        """
        return self.communication.connect()

    def disconnect(self) -> bool:
        """
        断开设备连接

        Returns:
            bool: 断开是否成功
        """
        try:
            self._heartbeat_monitor.stop_monitoring
            self._heartbeat_monitor.clear_status_change_callbacks()
        except:
            pass
        return self.communication.disconnect()

    def reconnect(self, max_attempts: int = 3) -> bool:
        """
        重新连接设备

        Args:
            max_attempts: 最大尝试次数

        Returns:
            bool: 重连是否成功
        """
        return self.communication.reconnect(max_attempts=max_attempts)

    def is_connected(self) -> bool:
        """
        检查设备连接状态

        Returns:
            bool: 设备是否已连接
        """
        return self.communication.is_available()

    def get_connection_status(self) -> Dict[str, Any]:
        """
        获取连接详细状态

        Returns:
            Dict[str, Any]: 连接状态详情
        """
        return self.communication.diagnose()

    # 2. 设备状态监控
    def get_device_status(self) -> Dict[str, Any]:
        """
        获取设备运行状态

        Returns:
            Dict[str, Any]: 设备运行状态信息
        """
        return self.communication.diagnose()

    def get_device_info(self) -> Dict[str, Any]:
        """
        获取设备基本信息

        Returns:
            Dict[str, Any]: 设备基本信息
        """
        return self.communication.get_device_info()

    def get_device_health(self) -> Dict[str, Any]:
        """
        获取设备健康状态

        Returns:
            Dict[str, Any]: 设备健康状态信息
        """
        try:
            return {"heartbeat":self._heartbeat_monitor.get_status()}
        except:
            return {}

    def monitor_heartbeat(self, interval: float = 1.0, callback: Callable[[Any], None]=None) -> bool:
        """
        心跳监控，启动心跳监控线程，每次手动重连都需要再启动

        Args:
            interval: 心跳间隔（秒）
            callback: 回调函数，用于接收心跳状态变化

        Returns:
            bool: 心跳是否正常
        """
        try:
           self._heartbeat_monitor.set_interval(interval)
           if callback is not None:
               self._heartbeat_monitor.add_status_change_callback(callback)
           return self._heartbeat_monitor.start_monitoring()
        except:
            return False

    # 4. 设备控制命令
    def start(self) -> bool:
        """
        启动设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 start 方法")

    def stop(self) -> bool:
        """
        停止设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 stop 方法")

    def pause(self) -> bool:
        """
        暂停设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 pause 方法")

    def resume(self) -> bool:
        """
        恢复设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 resume 方法")

    def reset(self) -> bool:
        """
        复位设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 reset 方法")

    def emergency_stop(self) -> bool:
        """
        紧急停止

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 emergency_stop 方法")

    # 5. 实时数据订阅
    def subscribe_tag(self, tag_name: str, callback: Callable[[Any], None],
                     **kwargs) -> str:
        """
        订阅标签变化

        Args:
            tag_name: 标签名称
            callback: 回调函数
            **kwargs: 其他参数

        Returns:
            str: 订阅ID
        """
        raise NotImplementedError("该设备未实现 subscribe_tag 方法")

    def unsubscribe_tag(self, subscription_id: str) -> bool:
        """
        取消标签订阅

        Args:
            subscription_id: 订阅ID

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 unsubscribe_tag 方法")

    def subscribe_device_status(self, callback: Callable[[Dict[str, Any]], None]) -> str:
        """
        订阅设备状态

        Args:
            callback: 回调函数

        Returns:
            str: 订阅ID
        """
        raise NotImplementedError("该设备未实现 subscribe_device_status 方法")

    def subscribe_alarms(self, callback: Callable[[Dict[str, Any]], None]) -> str:
        """
        订阅报警信息

        Args:
            callback: 回调函数

        Returns:
            str: 订阅ID
        """
        raise NotImplementedError("该设备未实现 subscribe_alarms 方法")

    # 6. 报警管理
    def get_active_alarms(self) -> List[Dict[str, Any]]:
        """
        获取活动报警

        Returns:
            List[Dict[str, Any]]: 活动报警列表
        """
        raise NotImplementedError("该设备未实现 get_active_alarms 方法")

    def get_alarm_history(self, start_time: Optional[str] = None,
                         end_time: Optional[str] = None) -> List[Dict[str, Any]]:
        """
        获取报警历史

        Args:
            start_time: 开始时间
            end_time: 结束时间

        Returns:
            List[Dict[str, Any]]: 报警历史列表
        """
        raise NotImplementedError("该设备未实现 get_alarm_history 方法")

    def acknowledge_alarm(self, alarm_id: str=None) -> bool:
        """
        确认报警，默认确认全部

        Args:
            alarm_id: 报警ID

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 acknowledge_alarm 方法")

    def clear_alarm(self, alarm_id: str=None) -> bool:
        """
        清除报警,默认清除全部

        Args:
            alarm_id: 报警ID

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 clear_alarm 方法")

    def suppress_alarm(self, alarm_id: str=None) -> bool:
        """
        抑制报警，默认抑制全部

        Args:
            alarm_id: 报警ID

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 suppress_alarm 方法")

    # 7. 参数配置
    def get_parameters(self, param_names: Optional[List[str]] = None) -> Dict[str, Any]:
        """
        获取设备参数

        Args:
            param_names: 参数名称列表，如果为None则获取所有参数

        Returns:
            Dict[str, Any]: 参数名和值的映射
        """
        # 如果没有指定参数名称，则返回所有配置
        if param_names is None:
            # 假设设备配置存储在通信接口的config属性中
            return self.communication.config if hasattr(self.communication, 'config') else {}

        # 如果指定了参数名称，则只返回这些参数的值
        result = {}
        for param_name in param_names:
            result[param_name] = self.communication.get_config(param_name)
        return result

    def set_parameters(self, param_dict: Dict[str, Any]) -> bool:
        """
        设置设备参数

        Args:
            param_dict: 参数名和值的映射

        Returns:
            bool: 操作是否成功
        """
        try:
            # 使用设备通信接口的set_config方法设置每个参数
            for param_name, param_value in param_dict.items():
                self.communication.set_config(param_name, param_value)
            return True
        except Exception as e:
            # 如果出现任何异常，返回False表示设置失败
            return False

    def save_parameters(self) -> bool:
        """
        保存参数到设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 save_parameters 方法")

    def load_parameters(self) -> Dict[str, Any]:
        """
        从设备加载参数

        Returns:
            Dict[str, Any]: 当前设备参数
        """
        raise NotImplementedError("该设备未实现 load_parameters 方法")

    def reset_parameters(self) -> bool:
        """
        恢复默认参数

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 reset_parameters 方法")

    # 8. 程序控制
    def load_program(self, program_name: str) -> bool:
        """
        加载程序

        Args:
            program_name: 程序名称

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 load_program 方法")

    def start_program(self, program_name: Optional[str] = None) -> bool:
        """
        启动程序

        Args:
            program_name: 程序名称，如果为None则启动当前加载的程序

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 start_program 方法")

    def stop_program(self) -> bool:
        """
        停止程序

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 stop_program 方法")

    def pause_program(self) -> bool:
        """
        暂停程序

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 pause_program 方法")

    def get_program_status(self) -> Dict[str, Any]:
        """
        获取程序状态

        Returns:
            Dict[str, Any]: 程序状态信息
        """
        raise NotImplementedError("该设备未实现 get_program_status 方法")


    # 10. IO控制
    def read_digital_input(self, address: Union[str, int]) -> bool:
        """
        读取数字输入

        Args:
            address: 地址

        Returns:
            bool: 输入值
        """
        raise NotImplementedError("该设备未实现 read_digital_input 方法")

    def read_digital_output(self, address: Union[str, int]) -> bool:
        """
        读取数字输出

        Args:
            address: 地址

        Returns:
            bool: 输出值
        """
        raise NotImplementedError("该设备未实现 read_digital_output 方法")

    def write_digital_output(self, address: Union[str, int], value: bool) -> bool:
        """
        写入数字输出

        Args:
            address: 地址
            value: 输出值

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 write_digital_output 方法")

    def read_analog_input(self, address: Union[str, int]) -> float:
        """
        读取模拟输入

        Args:
            address: 地址

        Returns:
            float: 输入值
        """
        raise NotImplementedError("该设备未实现 read_analog_input 方法")

    def write_analog_output(self, address: Union[str, int], value: float) -> bool:
        """
        写入模拟输出

        Args:
            address: 地址
            value: 输出值

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 write_analog_output 方法")

    # 13. 维护管理
    def get_maintenance_status(self) -> Dict[str, Any]:
        """
        获取维护状态

        Returns:
            Dict[str, Any]: 维护状态信息
        """
        raise NotImplementedError("该设备未实现 get_maintenance_status 方法")

    def schedule_maintenance(self, maintenance_type: str,
                           scheduled_time: str) -> bool:
        """
        安排维护

        Args:
            maintenance_type: 维护类型
            scheduled_time: 安排时间

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 schedule_maintenance 方法")

    def perform_maintenance(self, maintenance_type: str) -> bool:
        """
        执行维护

        Args:
            maintenance_type: 维护类型

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 perform_maintenance 方法")

    def get_maintenance_log(self) -> List[Dict[str, Any]]:
        """
        获取维护日志

        Returns:
            List[Dict[str, Any]]: 维护日志列表
        """
        raise NotImplementedError("该设备未实现 get_maintenance_log 方法")

    def reset_maintenance_counter(self, counter_name: str) -> bool:
        """
        重置维护计数器

        Args:
            counter_name: 计数器名称

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 reset_maintenance_counter 方法")

    # 14. 诊断功能
    def run_diagnostics(self) -> Dict[str, Any]:
        """
        运行诊断

        Returns:
            Dict[str, Any]: 诊断结果
        """
        raise NotImplementedError("该设备未实现 run_diagnostics 方法")

    def get_diagnostic_data(self) -> Dict[str, Any]:
        """
        获取诊断数据

        Returns:
            Dict[str, Any]: 诊断数据
        """
        raise NotImplementedError("该设备未实现 get_diagnostic_data 方法")

    def clear_diagnostics(self) -> bool:
        """
        清除诊断信息

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 clear_diagnostics 方法")

    def get_error_log(self) -> List[Dict[str, Any]]:
        """
        获取错误日志

        Returns:
            List[Dict[str, Any]]: 错误日志列表
        """
        raise NotImplementedError("该设备未实现 get_error_log 方法")

    def get_performance_metrics(self) -> Dict[str, Any]:
        """
        获取性能指标

        Returns:
            Dict[str, Any]: 性能指标
        """
        raise NotImplementedError("该设备未实现 get_performance_metrics 方法")

    # 15. 文件传输
    def upload_file(self, local_path: str, remote_path: str) -> bool:
        """
        上传文件到设备

        Args:
            local_path: 本地文件路径
            remote_path: 远程文件路径

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 upload_file 方法")

    def download_file(self, remote_path: str, local_path: str) -> bool:
        """
        从设备下载文件

        Args:
            remote_path: 远程文件路径
            local_path: 本地文件路径

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 download_file 方法")

    def delete_file(self, file_path: str) -> bool:
        """
        删除设备文件

        Args:
            file_path: 文件路径

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 delete_file 方法")

    def list_files(self, directory: str = "/") -> List[Dict[str, Any]]:
        """
        列出设备文件

        Args:
            directory: 目录路径

        Returns:
            List[Dict[str, Any]]: 文件列表
        """
        raise NotImplementedError("该设备未实现 list_files 方法")

    def get_file_info(self, file_path: str) -> Dict[str, Any]:
        """
        获取文件信息

        Args:
            file_path: 文件路径

        Returns:
            Dict[str, Any]: 文件信息
        """
        raise NotImplementedError("该设备未实现 get_file_info 方法")

    # 16. 时间管理
    def get_device_time(self) -> str:
        """
        获取设备时间

        Returns:
            str: 设备时间（ISO格式）
        """
        raise NotImplementedError("该设备未实现 get_device_time 方法")

    def set_device_time(self, time_str: str) -> bool:
        """
        设置设备时间

        Args:
            time_str: 时间字符串（ISO格式）

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 set_device_time 方法")

    def synchronize_time(self) -> bool:
        """
        时间同步

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 synchronize_time 方法")

    def get_time_zone(self) -> str:
        """
        获取时区信息

        Returns:
            str: 时区信息
        """
        raise NotImplementedError("该设备未实现 get_time_zone 方法")

    def set_time_zone(self, timezone: str) -> bool:
        """
        设置时区

        Args:
            timezone: 时区

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 set_time_zone 方法")

    # 17. 用户权限
    def login(self, username: str, password: str) -> bool:
        """
        用户登录

        Args:
            username: 用户名
            password: 密码

        Returns:
            bool: 登录是否成功
        """
        raise NotImplementedError("该设备未实现 login 方法")

    def logout(self) -> bool:
        """
        用户登出

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 logout 方法")

    def change_password(self, old_password: str, new_password: str) -> bool:
        """
        修改密码

        Args:
            old_password: 旧密码
            new_password: 新密码

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 change_password 方法")

    def get_user_permissions(self) -> List[str]:
        """
        获取用户权限

        Returns:
            List[str]: 权限列表
        """
        raise NotImplementedError("该设备未实现 get_user_permissions 方法")

    def set_user_permissions(self, permissions: List[str]) -> bool:
        """
        设置用户权限

        Args:
            permissions: 权限列表

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 set_user_permissions 方法")

    # 18. 安全功能
    def enable_safety(self) -> bool:
        """
        启用安全功能

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 enable_safety 方法")

    def disable_safety(self) -> bool:
        """
        禁用安全功能

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 disable_safety 方法")

    def get_safety_status(self) -> Dict[str, Any]:
        """
        获取安全状态

        Returns:
            Dict[str, Any]: 安全状态信息
        """
        raise NotImplementedError("该设备未实现 get_safety_status 方法")

    def reset_safety(self) -> bool:
        """
        复位安全状态

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 reset_safety 方法")

    def lock_device(self, lock: bool = True) -> bool:
        """
        锁定/解锁设备

        Args:
            lock: True为锁定，False为解锁

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 lock_device 方法")

    # 19. 通信管理
    def get_network_status(self) -> Dict[str, Any]:
        """
        获取网络状态

        Returns:
            Dict[str, Any]: 网络状态信息
        """
        raise NotImplementedError("该设备未实现 get_network_status 方法")

    def configure_network(self, config: Dict[str, Any]) -> bool:
        """
        配置网络参数

        Args:
            config: 网络配置

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 configure_network 方法")

    def restart_communication(self) -> bool:
        """
        重启通信

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 restart_communication 方法")

    def get_communication_log(self) -> List[Dict[str, Any]]:
        """
        获取通信日志

        Returns:
            List[Dict[str, Any]]: 通信日志列表
        """
        raise NotImplementedError("该设备未实现 get_communication_log 方法")

    def test_communication(self) -> bool:
        """
        测试通信

        Returns:
            bool: 通信是否正常
        """
        raise NotImplementedError("该设备未实现 test_communication 方法")

    # 20. 系统管理
    def reboot(self) -> bool:
        """
        重启设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 reboot 方法")

    def shutdown(self) -> bool:
        """
        关闭设备

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 shutdown 方法")

    def get_system_info(self) -> Dict[str, Any]:
        """
        获取系统信息

        Returns:
            Dict[str, Any]: 系统信息
        """
        raise NotImplementedError("该设备未实现 get_system_info 方法")

    def update_firmware(self, firmware_path: str) -> bool:
        """
        更新固件

        Args:
            firmware_path: 固件文件路径

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 update_firmware 方法")

    def backup_configuration(self, backup_path: str) -> bool:
        """
        备份配置

        Args:
            backup_path: 备份文件路径

        Returns:
            bool: 操作是否成功
        """
        raise NotImplementedError("该设备未实现 backup_configuration 方法")

    # 设备读取操作========================================================================================
    def read(self,
             address: FullReadType,
             *args: Union[
                 int,              # timeout (seconds)
                 float,            # timeout (seconds)
                 str,              # data_type or read_option
                 DataType,         # data type enum
                 ReadOption,       # read option enum
                 PreReaderType,    # pre-read processor function
                 PostReaderType,   # post-read processor function
                 Dict[str, Any]    # additional configuration
             ],
             timeout: Optional[Union[int, float]] = None,
             data_type: Optional[Union[str, DataType]] = None,
             sync: Optional[bool] = None,
             retry: Optional[int] = None,
             raise_on_error: Optional[bool] = None,
             quality_check: Optional[bool] = None,
             prereaders: Optional[List[PreReaderType]] = None,
             postreaders: Optional[List[PostReaderType]] = None,
             batch_size: Optional[int] = None,
             **kwargs: Any) -> Union[
                 Any,                     # single read result
                 List[Any],               # batch read results as list
                 Dict[AddressType, Any],  # batch read results as dict
                 Dict[str, Any]           # config read results
             ]:
        """
        严格类型定义的数据读取接口，支持多种读取格式和配置选项。

        该方法提供了一个统一的接口来从不同的地址读取各种类型的数据，支持单个读取、批量读取和配置读取等多种模式。
        可以通过位置参数、关键字参数或配置字典来指定读取参数，具有灵活的参数解析和配置合并机制。

        Args:
            address (FullReadType): 读取地址，支持以下几种类型：
                - AddressType: 单个地址，如 "address1" 或 100
                - List[AddressType]: 地址列表，如 ["address1", "address2"]
                - Tuple[AddressType, str]: 带数据类型的地址，如 ("address1", "int")
                - Tuple[AddressType, str, int]: 带数据类型和长度的地址，如 ("address1", "string", 4)
                - Tuple[AddressType, str, str]: 带数据类型和选项的地址，如 ("address1", "int", "option1")
                - List[Tuple[AddressType, str]]: 带数据类型的地址列表，如 [("address1", "int"), ("address2", "float")]
                - List[Tuple[AddressType, str, int]]: 带数据类型和长度的地址列表，如 [("address1", "string", 4), ("address2", "string", 4)]
                - List[Tuple[AddressType, str, str]]: 带数据类型和选项的地址列表，如 [("address1", "int", "option1"), ("address2", "float", "option2")]
                - Dict[str, Any]: 带配置的读取，支持以下格式：
                    - {"address": "address1", "data_type": "int"}: 单个地址配置读取
                    - {"addresses": ["address1", "address2"], "data_type": "int"}: 批量地址配置读取，数据类型一致
                    - {"addresses": ["address1", "address2"], "data_types": ["int", "float"]}: 批量地址配置读取，数据类型不一致
                    - {"address": "address1", "data_type": "int", "length": 4}: 带额外参数的配置读取

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次读取操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或读取选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定读取数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - ReadOption: 枚举类型参数，指定读取操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为prereader，
                           多参数函数被识别为postreader
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中
                - 其他类型参数将被忽略
        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次读取操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType]], optional): 指定读取数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步读取标志，指定读取操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步读取，False表示异步读取
            retry (Optional[int], optional): 读取失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次读取操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定读取失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回默认值或None
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在读取后进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            prereaders (Optional[List[PreReaderType]], optional): 读取前处理函数列表。
                这些函数将在数据读取前依次执行，用于准备读取操作
            postreaders (Optional[List[PostReaderType]], optional): 读取后处理函数列表。
                这些函数将在数据读取后依次执行，用于处理读取结果
            batch_size (Optional[int], optional): 批量读取分块大小，指定批量读取时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Union[Any, List[Any], Dict[AddressType, Any], Dict[str, Any]]: 读取结果，根据输入参数类型返回不同格式：
                - Any: 单个读取操作的结果，返回读取到的值
                - List[Any]: 批量读取操作的结果列表，按地址顺序返回读取值
                - Dict[AddressType, Any]: 批量读取操作的结果映射，键为地址，值为读取结果
                - Dict[str, Any]: 配置读取操作的结果，可能包含额外的元信息

        Raises:
            TypeError: 当传入不支持的地址格式时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当读取过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 单个读取：最简单的读取形式
            value = client.read("address1")

            # 带数据类型的单个读取：显式指定数据类型
            value = client.read(("address1", "int"))

            # 使用位置参数指定数据类型
            value = client.read("address1", "int")

            # 批量读取：通过列表一次读取多个地址
            values = client.read(["address1", "address2"])

            # 带配置的批量读取：通过元组列表指定多个地址和数据类型
            values = client.read([("address1", "int"), ("address2", "float")])

            # 带数据类型和选项的批量读取
            values = client.read([("address1", "int", "option1"), ("address2", "float", "option2")])

            # 使用关键字参数配置：通过关键字参数指定额外配置
            values = client.read("address1", timeout=10, data_type="int", sync=True)

            # 配置读取：通过配置字典执行读取操作
            result = client.read({
                "addresses": ["address1", "address2"],
                "data_type": "int"
            })

            # 带有所有可选参数的完整读取
            result = client.read(
                "address1",
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                retry=3,
                raise_on_error=True,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 读取选项包括SYNC, ASYNC
            4. 当batch_size参数设置且读取数据量超过该值时，将自动分块处理
            5. prereaders在数据读取前执行，postreaders在数据读取后执行
        """
        return self.communication.read(address,*args, timeout=timeout, data_type=data_type, sync=sync, retry=retry,
                                       raise_on_error=raise_on_error, quality_check=quality_check, prereaders=prereaders,
                                       postreaders=postreaders,batch_size=batch_size, **kwargs)


    def read_single(self,
                    address: AddressType,
                    *args: Union[
                        int,              # timeout (seconds)
                        float,            # timeout (seconds)
                        str,              # data_type or read_option
                        DataType,         # data type enum
                        ReadOption,       # read option enum
                        PreReaderType,    # pre-read processor function
                        PostReaderType,   # post-read processor function
                        Dict[str, Any]    # additional configuration
                    ],
                    timeout: Optional[Union[int, float]] = None,
                    data_type: Optional[Union[str, DataType]] = None,
                    sync: Optional[bool] = None,
                    retry: Optional[int] = None,
                    raise_on_error: Optional[bool] = None,
                    quality_check: Optional[bool] = None,
                    prereaders: Optional[List[PreReaderType]] = None,
                    postreaders: Optional[List[PostReaderType]] = None,
                    **kwargs: Any) -> Any:
        """
        读取单个地址的专用接口，提供针对单值读取的简化参数结构。

        Args:
            address (AddressType): 读取地址，支持字符串或数字类型地址，如 "address1" 或 100

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次读取操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或读取选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定读取数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - ReadOption: 枚举类型参数，指定读取操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为prereader，
                           多参数函数被识别为postreader
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中
                - 其他类型参数将被忽略
        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次读取操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType]], optional): 指定读取数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步读取标志，指定读取操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步读取，False表示异步读取
            retry (Optional[int], optional): 读取失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次读取操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定读取失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回默认值或None
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在读取后进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            prereaders (Optional[List[PreReaderType]], optional): 读取前处理函数列表。
                这些函数将在数据读取前依次执行，用于准备读取操作
            postreaders (Optional[List[PostReaderType]], optional): 读取后处理函数列表。
                这些函数将在数据读取后依次执行，用于处理读取结果

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Any: 单个读取操作的结果，返回读取到的值

        Raises:
            TypeError: 当传入不支持的地址格式时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当读取过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 最简单的单值读取
            value = client.read_single("address1")

            # 带数据类型的单值读取
            value = client.read_single("address1", "int")

            # 使用关键字参数配置
            value = client.read_single("address1", timeout=10, data_type="int", sync=True)

            # 带有所有可选参数的完整读取
            value = client.read_single(
                "address1",
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                retry=3,
                raise_on_error=True,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 读取选项包括SYNC, ASYNC
            4. prereaders在数据读取前执行，postreaders在数据读取后执行
        """
        return self.communication.read(address,*args,timeout=timeout,data_type=data_type,sync=sync,retry=retry,raise_on_error=raise_on_error,
                                       quality_check=quality_check,prereaders=prereaders,postreaders=postreaders,batch_size=1,**kwargs)

    def read_batch(self,
                   addresses: List[AddressType],
                   *args: Union[
                       int,              # timeout (seconds)
                       float,            # timeout (seconds)
                       str,              # data_type or read_option
                       DataType,         # data type enum
                       ReadOption,       # read option enum
                       PreReaderType,    # pre-read processor function
                       PostReaderType,   # post-read processor function
                       Dict[str, Any]    # additional configuration
                   ],
                   data_types: Optional[List[Union[str, DataType]]] = None,
                   timeout: Optional[Union[int, float]] = None,
                   sync: Optional[bool] = None,
                   retry: Optional[int] = None,
                   raise_on_error: Optional[bool] = None,
                   quality_check: Optional[bool] = None,
                   prereaders: Optional[List[PreReaderType]] = None,
                   postreaders: Optional[List[PostReaderType]] = None,
                   batch_size: Optional[int] = None,
                   **kwargs: Any) -> Union[
                       List[Any],               # batch read results as list
                       Dict[AddressType, Any]   # batch read results as dict
                   ]:
        """
        批量读取多个地址的专用接口，提供针对批量读取的优化参数结构。

        Args:
            addresses (List[AddressType]): 读取地址列表，支持字符串或数字类型地址，如 ["address1", "address2"] 或 [100, 200]
            data_types (Optional[List[Union[str, DataType]]], optional): 指定读取数据的类型列表，支持字符串或DataType枚举列表。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次读取操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或读取选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定读取数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - ReadOption: 枚举类型参数，指定读取操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为prereader，
                           多参数函数被识别为postreader
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中
                - 其他类型参数将被忽略

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            data_types (Optional[List[Union[str, DataType]]], optional): 指定读取数据的类型列表，支持字符串或DataType枚举列表。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            timeout (Optional[Union[int, float]], optional): 单次读取操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            sync (Optional[bool], optional): 同步读取标志，指定读取操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步读取，False表示异步读取
            retry (Optional[int], optional): 读取失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次读取操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定读取失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回默认值或None
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在读取后进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            prereaders (Optional[List[PreReaderType]], optional): 读取前处理函数列表。
                这些函数将在数据读取前依次执行，用于准备读取操作
            postreaders (Optional[List[PostReaderType]], optional): 读取后处理函数列表。
                这些函数将在数据读取后依次执行，用于处理读取结果
            batch_size (Optional[int], optional): 批量读取分块大小，指定批量读取时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Union[List[Any], Dict[AddressType, Any]]: 批量读取操作的结果，根据输入参数类型返回不同格式：
                - List[Any]: 批量读取操作的结果列表，按地址顺序返回读取值
                - Dict[AddressType, Any]: 批量读取操作的结果映射，键为地址，值为读取结果

        Raises:
            TypeError: 当传入不支持的地址格式时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当读取过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 最简单的批量读取
            values = client.read_batch(["address1", "address2"])

            # 带数据类型的批量读取（所有数据类型一致）
            values = client.read_batch(["address1", "address2"], data_types="int")

            # 带数据类型列表的批量读取（数据类型不一致）
            values = client.read_batch(["address1", "address2"], data_types=["int", "float"])

            # 使用关键字参数配置
            values = client.read_batch(["address1", "address2"], timeout=10, data_types="int", sync=True)

            # 带有所有可选参数的完整读取
            values = client.read_batch(
                ["address1", "address2"],
                timeout=30,
                data_types=[DataType.INT32, DataType.FLOAT],
                sync=True,
                retry=3,
                raise_on_error=True,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 读取选项包括SYNC, ASYNC
            4. 当batch_size参数设置且读取数据量超过该值时，将自动分块处理
            5. prereaders在数据读取前执行，postreaders在数据读取后执行
        """
        return self.communication.read(addresses,*args,data_type=data_types,timeout=timeout,sync=sync,retry=retry,raise_on_error=raise_on_error,
                                       quality_check=quality_check,prereaders=prereaders,postreaders=postreaders,batch_size=batch_size,**kwargs)

    def read_config(self,
                    config: Dict[str, Any],
                    *args: Union[
                        int,              # timeout (seconds)
                        float,            # timeout (seconds)
                        str,              # data_type or read_option
                        DataType,         # data type enum
                        ReadOption,       # read option enum
                        PreReaderType,    # pre-read processor function
                        PostReaderType,   # post-read processor function
                        Dict[str, Any]    # additional configuration
                    ],
                    timeout: Optional[Union[int, float]] = None,
                    data_type: Optional[Union[str, DataType]] = None,
                    sync: Optional[bool] = None,
                    retry: Optional[int] = None,
                    raise_on_error: Optional[bool] = None,
                    quality_check: Optional[bool] = None,
                    prereaders: Optional[List[PreReaderType]] = None,
                    postreaders: Optional[List[PostReaderType]] = None,
                    batch_size: Optional[int] = None,
                    **kwargs: Any) -> Dict[str, Any]:
        """
        通过配置字典进行读取的专用接口，提供针对配置读取的优化参数结构。

        Args:
            config (Dict[str, Any]): 读取配置字典，支持以下格式：
                - {"address": "address1", "data_type": "int"}: 单个地址配置读取
                - {"addresses": ["address1", "address2"], "data_type": "int"}: 批量地址配置读取，数据类型一致
                - {"addresses": ["address1", "address2"], "data_types": ["int", "float"]}: 批量地址配置读取，数据类型不一致
                - {"address": "address1", "data_type": "int", "length": 4}: 带额外参数的配置读取

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次读取操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或读取选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定读取数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - ReadOption: 枚举类型参数，指定读取操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为prereader，
                           多参数函数被识别为postreader
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中
                - 其他类型参数将被忽略

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次读取操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType]], optional): 指定读取数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步读取标志，指定读取操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步读取，False表示异步读取
            retry (Optional[int], optional): 读取失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次读取操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定读取失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回默认值或None
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在读取后进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            prereaders (Optional[List[PreReaderType]], optional): 读取前处理函数列表。
                这些函数将在数据读取前依次执行，用于准备读取操作
            postreaders (Optional[List[PostReaderType]], optional): 读取后处理函数列表。
                这些函数将在数据读取后依次执行，用于处理读取结果
            batch_size (Optional[int], optional): 批量读取分块大小，指定批量读取时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Dict[str, Any]: 配置读取操作的结果，可能包含额外的元信息

        Raises:
            TypeError: 当传入不支持的地址格式时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当读取过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 单个地址配置读取
            result = client.read_config({"address": "address1", "data_type": "int"})

            # 批量地址配置读取
            result = client.read_config({"addresses": ["address1", "address2"], "data_type": "int"})

            # 带数据类型列表的批量地址配置读取
            result = client.read_config({"addresses": ["address1", "address2"], "data_types": ["int", "float"]})

            # 使用关键字参数配置
            result = client.read_config(
                {"addresses": ["address1", "address2"], "data_type": "int"},
                timeout=10,
                sync=True
            )

            # 带有所有可选参数的完整读取
            result = client.read_config(
                {"addresses": ["address1", "address2"], "data_type": "int"},
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                retry=3,
                raise_on_error=True,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 读取选项包括SYNC, ASYNC
            4. 当batch_size参数设置且读取数据量超过该值时，将自动分块处理
            5. prereaders在数据读取前执行，postreaders在数据读取后执行
        """
        return self.communication.read(config,*args,timeout=timeout, data_type=data_type, sync=sync, retry=retry, raise_on_error=raise_on_error,
                                quality_check=quality_check,prereaders=prereaders,postreaders=postreaders,batch_size=batch_size, **kwargs)


    # 设备写操作==========================================================================
    def write(self,
              address: FullWriteType,
              value: Optional[Any] = None,
              *args: Union[
                  int,               # timeout (seconds)
                  float,             # timeout (seconds)
                  str,               # data_type or write_option
                  DataType,          # data type enum
                  WriteOption,       # write option enum
                  PreProcessorType,  # pre-write processor function
                  PostProcessorType, # post-write processor function
                  Dict[str, Any]     # additional configuration
              ],
              timeout: Optional[Union[int, float]] = None,
              data_type: Optional[Union[str, DataType, List[Union[str, DataType]]]] = None,
              sync: Optional[bool] = None,
              confirm: Optional[bool] = None,
              retry: Optional[int] = None,
              raise_on_error: Optional[bool] = None,
              quality_check: Optional[bool] = None,
              preprocessors: Optional[List[PreProcessorType]] = None,
              postprocessors: Optional[List[PostProcessorType]] = None,
              batch_size: Optional[int] = None,
              transaction: Optional[bool] = None,
              **kwargs: Any) -> Union[
                  bool,                    # single write result
                  Dict[AddressType, bool], # batch write results
                  Dict[str, Any]           # config write results
              ]:
        """
        严格类型定义的数据写入接口，支持多种写入格式和配置选项。

        该方法提供了一个统一的接口来写入各种类型的数据到不同的地址，支持单个写入、批量写入和配置写入等多种模式。
        可以通过位置参数、关键字参数或配置字典来指定写入参数，具有灵活的参数解析和配置合并机制。

        Args:
            address (FullWriteType): 写入地址，支持以下几种类型：
                - Tuple[AddressType, ValueType]: 单个地址值对，如 ("address1", 100)
                - Tuple[AddressType, ValueType, str]: 带数据类型的地址值对，如 ("address1", 100, "int")
                - Tuple[AddressType, ValueType, str, int]: 带数据类型和长度的地址值对，如 ("address1", 100, "int", 4)
                - Tuple[AddressType, ValueType, str, str]: 带数据类型和选项的地址值对，如 ("address1", 100, "int", "option1")
                - List[Tuple[AddressType, ValueType]]: 地址值对列表，如 [("address1", 100), ("address2", 200)]
                - List[Tuple[AddressType, ValueType, str]]: 带数据类型的地址值对列表，如 [("address1", 100, "int"), ("address2", 200, "float")]
                - List[Tuple[AddressType, ValueType, str, int]]: 带数据类型和长度的地址值对列表，如 [("address1", "stringadddressvalue", "string", 4), ("address2", "200", "string", 4)])]
                - List[Tuple[AddressType, ValueType, str, str]]: 带数据类型和选项的地址值对列表，如 [("address1", 100, "int", "option1"), ("address2", 200, "float", "option2")]
                - Dict[AddressType, ValueType]: 地址值对字典，如 {"address1": 100, "address2": 200}
                - Dict[str, Any]: 带配置的单个写入，如 {"address": "address1", "value": 100}
                - Dict[str, Any]: 带配置的单个写入，包括类型和其它参数如 {"address": "address1", "value": 100, "data_type": "int",...}
                - Dict[str, Any]: 带配置的批量写入，如 {"addresses": ["address1", "address2"], "values": [100, 200]}
                - Dict[str, Any]: 带配置的批量写入，数据类型一致，如 {"addresses": ["address1", "address2"], "values": [100, 200], "data_type": "int"}
                - Dict[str, Any]: 带配置的批量写入，数据类型不一致，如  {"addresses": ["address1", "address2"], "values": [100, 200], "data_types": ["int", "float"],"timeout": 10,...}
            value (Optional[Any], optional): 当address为单个地址时的写入值(单值)。默认为None。当value为Dict时，如 {"value": 100, "data_type": "int"}


        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次写入操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或写入选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定写入数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - WriteOption: 枚举类型参数，指定写入操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为preprocessor，
                           多参数函数被识别为postprocessor
                - Tuple: 协议特定参数元组，目前支持：
                         - Modbus参数: (slave_id, function_code)
                         - OPC UA参数: (namespace, node_id)
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次写入操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType, List[Union[str, DataType]]]], optional): 指定写入数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步写入标志，指定写入操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步写入，False表示异步写入
            confirm (Optional[bool], optional): 确认标志，指定是否需要写入确认，默认None表示使用系统默认设置
                True表示需要确认写入结果，False表示不检查写入结果
            retry (Optional[int], optional): 写入失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次写入操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定写入失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回False
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在写入前进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            preprocessors (Optional[List[PreProcessorType]], optional): 写入前处理函数列表。
                这些函数将在数据写入前依次执行，用于数据预处理或格式转换
            postprocessors (Optional[List[PostProcessorType]], optional): 写入后处理函数列表。
                这些函数将在数据写入后依次执行，用于处理写入结果
            batch_size (Optional[int], optional): 批量写入分块大小，指定批量写入时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现
            transaction (Optional[bool], optional): 事务标志，指定写入是否在事务中执行，默认None表示使用系统默认设置
                True表示在事务中执行写入，False表示普通写入

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Union[bool, Dict[AddressType, bool], Dict[str, Any]]: 写入结果，根据输入参数类型返回不同格式：
                - bool: 单个写入操作的结果，成功返回True，失败返回False
                - Dict[AddressType, bool]: 批量写入操作的结果映射，键为地址，值为布尔结果
                - Dict[str, Any]: 配置写入操作的结果，可能包含额外的元信息

        Raises:
            TypeError: 当传入不支持的地址/值组合时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当写入过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 单个写入：最简单的写入形式
            client.write("address1", 100)

            # 使用位置参数指定数据类型
            client.write("address1", 100, "int")

            # 带数据类型的单个写入：显式指定数据类型(元组)
            client.write(("address1", 100, "int"))

            # 带数据类型和长度的单个写入：指定数据类型和额外参数（长度）
            client.write(("address1", 100, "int", 4))

            # 批量写入：通过字典一次写入多个地址
            client.write({"address1": 100, "address2": 200})

            # 批量写入：通过元组列表指定多个地址和数据类型
            client.write(["address1", "address2"], [100, 200], ["int", "float"])

            # 带配置的批量写入：通过元组列表指定多个地址和数据类型
            client.write([("address1", 100, "int"), ("address2", 200, "float")])

            # 带数据类型和选项的批量写入
            client.write([("address1", 100, "int", "option1"), ("address2", 200, "float", "option2")])

            # 使用关键字参数配置：通过关键字参数指定额外配置
            client.write("address1", 100, timeout=10, data_type="int", sync=True)

            # 配置写入：通过配置字典执行写入操作
            client.write({
                "addresses": ["address1", "address2"],
                "values": [100, 200],
                "data_type": "int"
            })

            # 带有所有可选参数的完整写入
            client.write(
                "address1",
                100,
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                confirm=True,
                retry=3,
                raise_on_error=False,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 写入选项包括SYNC, ASYNC
            4. 当batch_size参数设置且写入数据量超过该值时，将自动分块处理
            5. preprocessors在数据写入前执行，postprocessors在数据写入后执行
        """
        return self.communication.write(address,value,*args,timeout=timeout,data_type=data_type,sync=sync,confirm=confirm,
                                        retry=retry,raise_on_error=raise_on_error,quality_check=quality_check,preprocessors=preprocessors,
                                        postprocessors=postprocessors,batch_size=batch_size,transaction=transaction,**kwargs)

    def write_single(self,
                     address: AddressType,
                     value: ValueType,
                     *args: Union[
                         int,               # timeout (seconds)
                         float,             # timeout (seconds)
                         str,               # data_type or write_option
                         DataType,          # data type enum
                         WriteOption,       # write option enum
                         PreProcessorType,  # pre-write processor function
                         PostProcessorType, # post-write processor function
                         Dict[str, Any]     # additional configuration
                     ],
                     data_type: Optional[Union[str, DataType]] = None,
                     timeout: Optional[Union[int, float]] = None,
                     sync: Optional[bool] = None,
                     confirm: Optional[bool] = None,
                     retry: Optional[int] = None,
                     raise_on_error: Optional[bool] = None,
                     quality_check: Optional[bool] = None,
                     preprocessors: Optional[List[PreProcessorType]] = None,
                     postprocessors: Optional[List[PostProcessorType]] = None,
                     transaction: Optional[bool] = None,
                     **kwargs: Any) -> bool:
        """
        写入单个地址值对的专用接口，提供针对单值写入的简化参数结构。

        Args:
            address (AddressType): 写入地址，支持字符串或数字类型地址，如 "address1" 或 100
            value (ValueType): 写入值，支持任意类型的数据，如 100, "value", True 等

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次写入操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或写入选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定写入数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - WriteOption: 枚举类型参数，指定写入操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为preprocessor，
                           多参数函数被识别为postprocessor
                - Tuple: 协议特定参数元组，目前支持：
                         - Modbus参数: (slave_id, function_code)
                         - OPC UA参数: (namespace, node_id)
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次写入操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType]], optional): 指定写入数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步写入标志，指定写入操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步写入，False表示异步写入
            confirm (Optional[bool], optional): 确认标志，指定是否需要写入确认，默认None表示使用系统默认设置
                True表示需要确认写入结果，False表示不检查写入结果
            retry (Optional[int], optional): 写入失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次写入操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定写入失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回False
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在写入前进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            preprocessors (Optional[List[PreProcessorType]], optional): 写入前处理函数列表。
                这些函数将在数据写入前依次执行，用于数据预处理或格式转换
            postprocessors (Optional[List[PostProcessorType]], optional): 写入后处理函数列表。
                这些函数将在数据写入后依次执行，用于处理写入结果
            transaction (Optional[bool], optional): 事务标志，指定写入是否在事务中执行，默认None表示使用系统默认设置
                True表示在事务中执行写入，False表示普通写入

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            bool: 单个写入操作的结果，成功返回True，失败返回False

        Raises:
            TypeError: 当传入不支持的地址/值组合时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当写入过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 最简单的单值写入
            result = client.write_single("address1", 100)

            # 带数据类型的单值写入
            result = client.write_single("address1", 100, "int")

            # 使用关键字参数配置
            result = client.write_single("address1", 100, timeout=10, data_type="int", sync=True)

            # 带有所有可选参数的完整写入
            result = client.write_single(
                "address1",
                100,
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                confirm=True,
                retry=3,
                raise_on_error=False,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 写入选项包括SYNC, ASYNC
            4. preprocessors在数据写入前执行，postprocessors在数据写入后执行
        """
        return self.communication.write(address, value, *args,timeout=timeout,data_type=data_type,sync=sync,confirm=confirm,retry=retry,
                                        raise_on_error=raise_on_error,quality_check=quality_check,preprocessors=preprocessors,
                                        postprocessors=postprocessors,transaction=transaction,**kwargs)


    def write_batch(self,
                    addresses: List[AddressType],
                    values: List[ValueType],
                    *args: Union[
                        int,               # timeout (seconds)
                        float,             # timeout (seconds)
                        str,               # data_type or write_option
                        DataType,          # data type enum
                        WriteOption,       # write option enum
                        PreProcessorType,  # pre-write processor function
                        PostProcessorType, # post-write processor function
                        Dict[str, Any]     # additional configuration
                    ],
                    data_types: Optional[List[Union[str, DataType]]] = None,
                    timeout: Optional[Union[int, float]] = None,
                    sync: Optional[bool] = None,
                    confirm: Optional[bool] = None,
                    retry: Optional[int] = None,
                    raise_on_error: Optional[bool] = None,
                    quality_check: Optional[bool] = None,
                    preprocessors: Optional[List[PreProcessorType]] = None,
                    postprocessors: Optional[List[PostProcessorType]] = None,
                    batch_size: Optional[int] = None,
                    transaction: Optional[bool] = None,
                    **kwargs: Any) -> Dict[AddressType, bool]:
        """
        批量写入多个地址值对的专用接口，提供针对批量写入的优化参数结构。

        Args:
            addresses (List[AddressType]): 写入地址列表，支持字符串或数字类型地址，如 ["address1", "address2"] 或 [100, 200]
            values (List[ValueType]): 写入值列表，支持任意类型的数据，如 [100, 200], ["value1", "value2"], [True, False] 等
            data_types (Optional[List[Union[str, DataType]]], optional): 指定写入数据的类型列表，支持字符串或DataType枚举列表。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次写入操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或写入选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定写入数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - WriteOption: 枚举类型参数，指定写入操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为preprocessor，
                           多参数函数被识别为postprocessor
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            data_types (Optional[List[Union[str, DataType]]], optional): 指定写入数据的类型列表，支持字符串或DataType枚举列表。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            timeout (Optional[Union[int, float]], optional): 单次写入操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            sync (Optional[bool], optional): 同步写入标志，指定写入操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步写入，False表示异步写入
            confirm (Optional[bool], optional): 确认标志，指定是否需要写入确认，默认None表示使用系统默认设置
                True表示需要确认写入结果，False表示不检查写入结果
            retry (Optional[int], optional): 写入失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次写入操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定写入失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回False
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在写入前进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            preprocessors (Optional[List[PreProcessorType]], optional): 写入前处理函数列表。
                这些函数将在数据写入前依次执行，用于数据预处理或格式转换
            postprocessors (Optional[List[PostProcessorType]], optional): 写入后处理函数列表。
                这些函数将在数据写入后依次执行，用于处理写入结果
            batch_size (Optional[int], optional): 批量写入分块大小，指定批量写入时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现
            transaction (Optional[bool], optional): 事务标志，指定写入是否在事务中执行，默认None表示使用系统默认设置
                True表示在事务中执行写入，False表示普通写入

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Dict[AddressType, bool]: 批量写入操作的结果映射，键为地址，值为布尔结果

        Raises:
            TypeError: 当传入不支持的地址/值组合时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当写入过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 最简单的批量写入
            result = client.write_batch(["address1", "address2"], [100, 200])

            # 最简单的批量写入（带数据类型）
            result = client.write_batch(["address1", "address2"], [100, 200],["int", "float"])

            # 带数据类型的批量写入（所有数据类型一致）
            result = client.write_batch(["address1", "address2"], [100, 200], data_types="int")

            # 带数据类型列表的批量写入（数据类型不一致）
            result = client.write_batch(["address1", "address2"], [100, 200.5], data_types=["int", "float"])

            # 使用关键字参数配置
            result = client.write_batch(["address1", "address2"], [100, 200], timeout=10, data_types="int", sync=True)

            # 带有所有可选参数的完整写入
            result = client.write_batch(
                ["address1", "address2"],
                [100, 200],
                timeout=30,
                data_types=[DataType.INT32, DataType.FLOAT],
                sync=True,
                confirm=True,
                retry=3,
                raise_on_error=False,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 写入选项包括SYNC, ASYNC
            4. 当batch_size参数设置且写入数据量超过该值时，将自动分块处理
            5. preprocessors在数据写入前执行，postprocessors在数据写入后执行
        """
        # address_param = {"addresses": addresses, "values": values}
        return self.communication.write(addresses, values,*args,timeout=timeout,data_type=data_types,sync=sync,confirm=confirm,retry=retry,
                                        raise_on_error=raise_on_error,quality_check=quality_check,preprocessors=preprocessors,
                                        postprocessors=postprocessors,batch_size=batch_size,transaction=transaction,**kwargs)

    def write_config(self,
                     config: Dict[str, Any],
                     *args: Union[
                         int,               # timeout (seconds)
                         float,             # timeout (seconds)
                         str,               # data_type or write_option
                         DataType,          # data type enum
                         WriteOption,       # write option enum
                         PreProcessorType,  # pre-write processor function
                         PostProcessorType, # post-write processor function
                         Dict[str, Any]     # additional configuration
                     ],
                     timeout: Optional[Union[int, float]] = None,
                     data_type: Optional[Union[str, DataType]] = None,
                     sync: Optional[bool] = None,
                     confirm: Optional[bool] = None,
                     retry: Optional[int] = None,
                     raise_on_error: Optional[bool] = None,
                     quality_check: Optional[bool] = None,
                     preprocessors: Optional[List[PreProcessorType]] = None,
                     postprocessors: Optional[List[PostProcessorType]] = None,
                     batch_size: Optional[int] = None,
                     transaction: Optional[bool] = None,
                     **kwargs: Any) -> Dict[str, Any]:
        """
        通过配置字典进行写入的专用接口，提供针对配置写入的优化参数结构。

        Args:
            config (Dict[str, Any]): 写入配置字典，支持以下格式：
                - {"address": "address1", "value": 100}: 单个地址配置写入
                - {"address": "address1", "value": 100,"data_type": "int"}: 单个地址配置写入
                - {"addresses": ["address1", "address2"], "values": [100, 200]}: 批量地址配置写入
                - {"addresses": ["address1", "address2"], "values": [100, 200], "data_type": "int"}: 带数据类型的批量地址配置写入
                - {"addresses": ["address1", "address2"], "values": [100, 200], "data_types": ["int", "float"]}: 带数据类型列表的批量地址配置写入

        Positional Args:
            *args: 位置参数，支持以下类型：
                - int/float: 超时时间（秒），用于指定单次写入操作的最大等待时间
                - str: 数据类型标识符，支持DataType枚举的字符串值（如'int', 'float'等）或写入选项标识符（如'sync', 'async'）
                - DataType: 枚举类型参数，明确指定写入数据的类型，包含丰富类型支持如：
                            INT16, UINT16, INT32, UINT32, FLOAT, DOUBLE, STRING等
                - WriteOption: 枚举类型参数，指定写入操作模式，包含SYNC（同步）和ASYNC（异步）模式
                - Callable: 可调用对象，用于数据预处理和后处理。无参数或单参数函数被识别为preprocessor，
                           多参数函数被识别为postprocessor
                - Dict[str, Any]: 额外配置参数，将直接合并到最终配置字典中

        Keyword Args:
            以下关键字参数提供了更明确的配置方式，优先级高于*args中的参数：

            timeout (Optional[Union[int, float]], optional): 单次写入操作的最大等待时间（秒），默认None表示使用系统默认超时时间
                如果在指定时间内操作未完成，将引发超时异常（如果raise_on_error=True）
            data_type (Optional[Union[str, DataType]], optional): 指定写入数据的类型，支持字符串或DataType枚举。
                默认为None，表示自动推断数据类型。常用类型包括'int', 'float', 'string', 'bool'等
            sync (Optional[bool], optional): 同步写入标志，指定写入操作是同步还是异步执行，默认None表示使用系统默认设置
                True表示同步写入，False表示异步写入
            confirm (Optional[bool], optional): 确认标志，指定是否需要写入确认，默认None表示使用系统默认设置
                True表示需要确认写入结果，False表示不检查写入结果
            retry (Optional[int], optional): 写入失败时的重试次数，默认None表示使用系统默认重试次数
                0表示不重试，仅执行一次写入操作
            raise_on_error (Optional[bool], optional): 错误处理标志，指定写入失败时是否抛出异常，默认None表示使用系统默认设置
                True表示抛出异常，False表示返回False
            quality_check (Optional[bool], optional): 数据质量检查标志，指定是否在写入前进行数据质量检查，默认None表示使用系统默认设置
                True表示进行质量检查，False表示跳过质量检查
            preprocessors (Optional[List[PreProcessorType]], optional): 写入前处理函数列表。
                这些函数将在数据写入前依次执行，用于数据预处理或格式转换
            postprocessors (Optional[List[PostProcessorType]], optional): 写入后处理函数列表。
                这些函数将在数据写入后依次执行，用于处理写入结果
            batch_size (Optional[int], optional): 批量写入分块大小，指定批量写入时每个分块的大小。
                None表示不分块处理，默认值依赖于具体实现
            transaction (Optional[bool], optional): 事务标志，指定写入是否在事务中执行，默认None表示使用系统默认设置
                True表示在事务中执行写入，False表示普通写入

            **kwargs: 其他关键字参数，将被合并到配置中，支持所有在args中提到的参数类型，
                以及额外的协议特定参数。这些参数将覆盖通过*args解析的参数

        Returns:
            Dict[str, Any]: 配置写入操作的结果，可能包含额外的元信息

        Raises:
            TypeError: 当传入不支持的地址/值组合时，或者参数类型不匹配时抛出
            ValueError: 当质量检查失败时（如果启用了quality_check），或者参数值无效时抛出
            Exception: 当写入过程中发生错误且raise_on_error=True时抛出

        Examples:
            # 单个地址配置写入
            result = client.write_config({"address": "address1", "value": 100})

            # 单个地址配置写入
            result = client.write_config({"address": "address1", "value": 100,"data_type": "int"})

            # 批量地址配置写入
            result = client.write_config({"addresses": ["address1", "address2"], "values": [100, 200]})

            # 带数据类型的批量地址配置写入
            result = client.write_config({
                "addresses": ["address1", "address2"],
                "values": [100, 200],
                "data_type": "int"
            })

            # 带数据类型列表的批量地址配置写入
            result = client.write_config({
                "addresses": ["address1", "address2"],
                "values": [100, 200.5],
                "data_types": ["int", "float"]
            })

            # 使用关键字参数配置
            result = client.write_config(
                {"addresses": ["address1", "address2"], "values": [100, 200]},
                timeout=10,
                data_type="int",
                sync=True
            )

            # 带有所有可选参数的完整写入
            result = client.write_config(
                {"addresses": ["address1", "address2"], "values": [100, 200]},
                timeout=30,
                data_type=DataType.INT32,
                sync=True,
                confirm=True,
                retry=3,
                raise_on_error=False,
                quality_check=True
            )

        Note:
            1. 参数优先级：kwargs > args > defaults
            2. 支持的数据类型包括所有DataType枚举值
            3. 写入选项包括SYNC, ASYNC
            4. 当batch_size参数设置且写入数据量超过该值时，将自动分块处理
            5. preprocessors在数据写入前执行，postprocessors在数据写入后执行
        """
        return self.communication.write(config, *args,timeout=timeout,data_type=data_type,sync=sync,confirm=confirm,retry=retry,
                                        raise_on_error=raise_on_error,quality_check=quality_check,preprocessors=preprocessors,
                                        postprocessors=postprocessors,batch_size=batch_size,transaction=transaction,**kwargs)
